// pages/reviews/reviews.js
const app = getApp()
const reviewApi = require('../../utils/reviewApi')

Page({

  /**
   * 页面的初始数据
   */
  data: {
    activeTab: 'all',
    productId: null,
    reviews: [],
    userInfo: null,
    loading: false,
    hasMore: true,
    page: 0,
    size: 10,
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('评论页面参数:', options);
    const userInfo = wx.getStorageSync('userInfo')
    
    // 检查是否传入商品ID
    if (options.productId) {
      this.setData({ 
        userInfo,
        productId: options.productId,
        activeTab: 'all'  // 设置默认标签为全部评论
      })
    } else if (userInfo && userInfo.id) {
      // 如果没有商品ID但有用户信息，默认显示用户评论
      this.setData({ 
        userInfo,
        activeTab: 'my'  // 设置默认标签为我的评论
      })
    } else {
      // 两者都没有的情况
      this.setData({ 
        userInfo,
        activeTab: 'my'  // 默认我的评论，但后续会检查是否有权限
      })
      
      // 提示用户
      wx.showToast({
        title: '未指定商品或未登录',
        icon: 'none',
        duration: 2000
      })
    }
    
    this.loadReviews()
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.setData({
      reviews: [],
      page: 1,
      hasMore: true
    })
    this.loadReviews().then(() => {
      wx.stopPullDownRefresh()
    })
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  // 切换标签
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab
    this.setData({
      activeTab: tab,
      reviews: [],
      page: 1,
      hasMore: true
    })
    this.loadReviews()
  },

  // 加载评论列表
  async loadReviews() {
    if (this.data.loading || !this.data.hasMore) return

    try {
      console.log('开始加载评论列表');
      this.setData({ loading: true })
      const { activeTab, page, size, userInfo, productId } = this.data

      // 添加参数预检查
      if (activeTab === 'all' && !productId) {
        throw new Error('缺少商品ID，无法加载评论');
      }
      
      if ((activeTab === 'my' || activeTab === 'liked') && (!userInfo || !userInfo.id)) {
        throw new Error('请先登录后查看');
      }

      let res;
      
      // 根据不同情况调用不同的API
      if (activeTab === 'all' && productId) {
        console.log('加载商品评论, 商品ID:', productId);
        res = await reviewApi.getProductReviews(productId, page, size);
      } else if (activeTab === 'my' && userInfo && userInfo.id) {
        console.log('加载用户评论, 用户ID:', userInfo.id);
        res = await reviewApi.getUserReviews(userInfo.id, { page, size });
      } else if (activeTab === 'liked' && userInfo && userInfo.id) {
        // 加载用户点赞的评论
        console.log('加载用户点赞评论, 用户ID:', userInfo.id);
        res = await reviewApi.getUserLikedReviews(userInfo.id, { page, size });
      } else {
        throw new Error('无效的请求参数');
      }

      console.log('API响应结果:', res);
      
      if (res && res.success) {
        const { content, last } = res.data || {};
        
        if (!content || !Array.isArray(content)) {
          console.error('API返回数据格式错误:', res.data);
          throw new Error('返回数据格式不正确');
        }
        
        // 处理评论数据
        const formattedReviews = content.map(review => {
          // 确保评论有商品信息
          const product = review.product || {};
          if (product) {
            // 确保商品有图片
            product.imageUrl = product.imageUrl || '/images/default-product.png';
          }
          
          // 确保评论图片URLs正确
          let imageUrls = review.imageUrls || [];
          if (imageUrls && !Array.isArray(imageUrls)) {
            // 如果不是数组，尝试转换
            try {
              imageUrls = typeof imageUrls === 'string' ? JSON.parse(imageUrls) : [];
            } catch (e) {
              console.error('解析评论图片URLs失败:', e);
              imageUrls = [];
            }
          }
          
          // 格式化日期
          return {
            ...review,
            product: product,
            imageUrls: imageUrls,
            createTime: this.formatTime(review.createTime || new Date()),
            replies: Array.isArray(review.replies) 
              ? review.replies.map(reply => ({
                ...reply,
                createTime: this.formatTime(reply.createTime || new Date())
              })) 
              : []
          };
        });
        
        this.setData({
          reviews: page === 0 ? formattedReviews : [...this.data.reviews, ...formattedReviews],
          page: page + 1,
          hasMore: !last,
          loading: false
        });
        
        console.log('评论加载完成, 数量:', formattedReviews.length);
      } else {
        throw new Error((res && res.message) || '加载失败');
      }
    } catch (error) {
      console.error('加载评论失败:', error);
      wx.showToast({
        title: error.message || '加载失败',
        icon: 'none'
      });
      this.setData({ 
        loading: false,
        hasMore: false // 加载失败时设置为没有更多，防止无限重试
      });
    }
  },

  // 格式化时间
  formatTime(timeStr) {
    if (!timeStr) return '';
    try {
      const date = new Date(timeStr);
      const year = date.getFullYear();
      const month = (date.getMonth() + 1).toString().padStart(2, '0');
      const day = date.getDate().toString().padStart(2, '0');
      const hour = date.getHours().toString().padStart(2, '0');
      const minute = date.getMinutes().toString().padStart(2, '0');
      return `${year}-${month}-${day} ${hour}:${minute}`;
    } catch (e) {
      console.error('时间格式化错误:', e);
      return timeStr;
    }
  },

  // 加载更多
  loadMore() {
    this.loadReviews()
  },

  // 跳转到商品详情
  goToProduct(e) {
    const { id } = e.currentTarget.dataset
    wx.navigateTo({
      url: `/pages/product/product?id=${id}`
    })
  },

  // 预览图片
  previewImage(e) {
    const { urls, current } = e.currentTarget.dataset
    
    // 检查是否有有效的URL
    if (!urls || !Array.isArray(urls) || urls.length === 0) {
      console.error('预览图片失败: 没有可用的图片URL');
      wx.showToast({
        title: '无法预览图片',
        icon: 'none'
      });
      return;
    }
    
    // 过滤掉无效的URL
    const validUrls = urls.filter(url => url && url !== 'undefined' && url !== 'null');
    
    if (validUrls.length === 0) {
      wx.showToast({
        title: '无法预览图片',
        icon: 'none'
      });
      return;
    }
    
    // 确保当前URL在有效列表中
    const currentUrl = current && validUrls.includes(current) ? current : validUrls[0];
    
    wx.previewImage({
      urls: validUrls,
      current: currentUrl
    })
  },

  // 处理评论图片加载错误
  onImageError(e) {
    console.log('评论图片加载错误:', e);
    const { reviewIndex, imageIndex } = e.currentTarget.dataset;
    
    // 构建更新路径
    const updatePath = `reviews[${reviewIndex}].imageUrls[${imageIndex}]`;
    
    // 设置为默认图片
    this.setData({
      [updatePath]: '/images/default-product.png'
    });
  },
  
  // 处理商品图片加载错误
  onProductImageError(e) {
    console.log('商品图片加载错误:', e);
    const { reviewIndex } = e.currentTarget.dataset;
    
    // 构建更新路径
    const updatePath = `reviews[${reviewIndex}].product.imageUrl`;
    
    // 设置为默认图片
    this.setData({
      [updatePath]: '/images/default-product.png'
    });
  },

  // 点赞/取消点赞评论
  async toggleLike(e) {
    const { id } = e.currentTarget.dataset
    const { reviews } = this.data
    const review = reviews.find(item => item.id === id)
    
    if (!review) return

    try {
      if (review.isLiked) {
        await reviewApi.unlikeReview(id)
      } else {
        await reviewApi.likeReview(id)
      }

      review.isLiked = !review.isLiked
      review.likesCount = review.isLiked 
        ? (review.likesCount || 0) + 1 
        : (review.likesCount || 1) - 1
      
      this.setData({ reviews })
    } catch (error) {
      console.error('操作失败:', error)
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      })
    }
  },

  // 删除评论
  deleteReview(e) {
    const { id } = e.currentTarget.dataset
    
    wx.showModal({
      title: '提示',
      content: '确定要删除这条评论吗？',
      success: async (res) => {
        if (res.confirm) {
          try {
            const res = await reviewApi.deleteReview(id)
            if (res.success) {
              const reviews = this.data.reviews.filter(item => item.id !== id)
              this.setData({ reviews })
              wx.showToast({
                title: '删除成功',
                icon: 'success'
              })
            }
          } catch (error) {
            console.error('删除评论失败:', error)
            wx.showToast({
              title: '删除失败',
              icon: 'none'
            })
          }
        }
      }
    })
  },

  // 举报评论
  reportReview(e) {
    const { id } = e.currentTarget.dataset
    wx.showModal({
      title: '举报',
      content: '确定要举报这条评论吗？',
      success: (res) => {
        if (res.confirm) {
          // TODO: 实现举报功能
          wx.showToast({
            title: '举报成功',
            icon: 'success'
          })
        }
      }
    })
  }
})